/***************************************************************************
 *   Copyright (C) 2004 by cyril dupuit                                    *
 *   cyrildupuit@hotmail.com                                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

//*****************************************************************************
// Nom du module : Console.h
// Description : Gestion de l'affichage en mode texte.
//*****************************************************************************
 
// Historique :
// 21/01/05 : Creation du module V1.0  

#include "Misc/Console.h"
#include "Config.h"
#include "Kernel/Types.h"
#include "Kernel/Core.h"
#include "Kernel/Semaphor.h"
#include "Kernel/DynTimer.h"

#ifndef CONSOLE_PROC_HEADER
#define CONSOLE_PROC_HEADER

//*****************************************************************************
// Definition des equivalences
//*****************************************************************************
#define COMMAND_PORT 0x3D4
#define DATA_PORT    0x3D5

#define CURSOR_START 0xA
#define CURSOR_END   0xB
#define ADDRESS_HIGH 0xC
#define ADDRESS_LOW  0xD
#define CURSOR_HIGH  0xE
#define CURSOR_LOW   0xF

#define REFRESH		0x4000
#define PARTIAL_REFRESH	0x8000

//*****************************************************************************
// Definition des macros 
//*****************************************************************************

//Activer le curseur en mode d'insertion
#define EnableCursorIns OutByte(COMMAND_PORT, CURSOR_START); \
			OutByte(DATA_PORT, (InByte(DATA_PORT) & 0xE0) | 0x0B);\
			OutByte(COMMAND_PORT, CURSOR_END); \
			OutByte(DATA_PORT, (InByte(DATA_PORT) & 0xE0) | 0x0F);

//Desactiver le curseur du mode d'insertion
#define DisableCursorIns OutByte(COMMAND_PORT, CURSOR_START); \
			OutByte(DATA_PORT, InByte(DATA_PORT) & 0xE0);\
			OutByte(COMMAND_PORT, CURSOR_END); \
			OutByte(DATA_PORT, (InByte(DATA_PORT) & 0xE0) | 0x0C);

//Desactiver le curseur (Bit 5 = 1)
#define DisableCursor OutByte(COMMAND_PORT, CURSOR_START); \
			OutByte(DATA_PORT, InByte(DATA_PORT) | 0x20);

//Activer le curseur (Bit 5 = 0)
#define EnableCursor OutByte(COMMAND_PORT, CURSOR_START); \
			OutByte(DATA_PORT, InByte(DATA_PORT) & 0xDF);

//Position du curseur
#define SetCursorPosition(Pos) 	OutByte(COMMAND_PORT, CURSOR_HIGH); \
				OutByte(DATA_PORT, (unsigned char)(Pos >> 8)); \
                                OutByte(COMMAND_PORT, CURSOR_LOW); \
                                OutByte(DATA_PORT, (unsigned char)Pos);

#define RedrawRegion(pConsole, StartX, StartY, EndX, EndY) \
	{ \
	if(StartX < pConsole->RedrawStart.X) pConsole->RedrawStart.X = StartX; \
	if(StartY < pConsole->RedrawStart.Y) pConsole->RedrawStart.Y = StartY; \
	if(EndX > pConsole->RedrawEnd.X) pConsole->RedrawEnd.X = EndX; \
	if(EndY > pConsole->RedrawEnd.Y) pConsole->RedrawEnd.Y = EndY; \
	Set(pConsole->Status, PARTIAL_REFRESH); \
	}

//*****************************************************************************
// But de la procedure : Affecter une console
// Supprime le timer et affecte la nouvelle console
// Entree : Aucune
// Sortie : Aucune
//*****************************************************************************
void ConsoleAffect(void);

//*****************************************************************************
// But de la tache : Se mettre en attente sur un semaphore afin d'effectuer un
// changement de console
// Entree : Aucune
// Sortie : Aucune
//*****************************************************************************
void TaskConsoleChanger(void);

//*****************************************************************************
// But de la tache : Se mettre en attente sur un semaphore afin d'effectuer une
// selection de console
// Entree : Aucune
// Sortie : Aucune
//*****************************************************************************
void TaskConsoleSelector(void);

//*****************************************************************************
// But de la fonction : Aider l'utilisateur a selectionner une console
// Entree : Aucune
// Sottie : Aucune
// Parametre retourne : FALSE si console non change, ERROR si pConsole errone,
//  TRUE sinon
//*****************************************************************************
Status_t ConsoleSelect(void);

//*****************************************************************************
// But de la tache : Raffraichir la console courante
// Entree : Aucune
// Sortie : Aucune
//*****************************************************************************
void TaskRefreshConsole(void);

//*****************************************************************************
// But de la procedure : Tracer une ligne de X1 a X2 a l'ordonne Y
// Entrees :
//	x1 : Point de depart des abscisses
//	Y : Ordonnees
//	x2 : Point d'arrive
//	c : Couleur de la ligne
// Sortie : Aucune
//*****************************************************************************
void Line(CNode_t * pConsole, int x1, int y, int x2, int c);

//*****************************************************************************
//But de la procedure : Dessiner un point a l'ecran de la console
// Entrees :
//	pConsole : Pointeur sur la console
//	X : Abscisse
//	Y : Coordonne
//	Color : Couleur du "pixel"
// Sortie : Aucune
//*****************************************************************************
void Pixel(CNode_t * pConsole,Coord_t X, Coord_t Y, Color_t Color);

//*****************************************************************************
// But de la procedure : vider le buffer memoire associe a la console
// Entree : 
//	pConsole : Pointeur sur la console
// Sortie : Aucune
//*****************************************************************************
void Clear(CNode_t * pConsole);

//*****************************************************************************
// But de la fonction : Effacer les caracteres se trouvant a gauche du curseur
// Entrees :
//	pConsole : Pointeur sur la console
// Parametre retourne : FALSE si aucun caractere ecrit, TRUE sinon
//*****************************************************************************
Status_t BackSpace(CNode_t * pConsole);

//*****************************************************************************
// But de la procedure : Annoncer la fin de la saisie d'une ligne
// Entrees :
//	pConsole : Pointeur sur la console
// Sortie : Aucune
//*****************************************************************************
void Return(CNode_t * pConsole);

//*****************************************************************************
// But de la procedure : Ecrire un caractere ainsi que son attribut a un
// emplacement specifique dans le tampon memoire
// Entrees :
//	pConsole : Pointeur sur la console
// C : Caractere a ecrire
// FontColor : Couleur du caractere
// BackColor : Couleur du fond d'ecran
//*****************************************************************************
void Write(CNode_t * pConsole, const char C);

//*****************************************************************************
// But de la procedure : Decaler le contenu du buffer de la console vers le
// haut d'une ligne
// Entree :
//	pConsole : Pointeur sur la console
// Sortie : Aucune
//*****************************************************************************
Status_t BufferOffset(CNode_t * pConsole);

//*****************************************************************************
// But de la procedure : Recadrer la fenetre
// Entree :
//	pConsole : Pointeur sur la console
// Sortie : Aucune
//*****************************************************************************
void WindowPosition(CNode_t * pConsole);

//*****************************************************************************
// But de la procedure : Afficher une chaine de caracteres de longueur Number
// a un endroit de l'ecran
// Entrees :
//	P : Coordonnees du point de depart de l'affichage
//	pString : Pointeur sur la chaine de caracteres
//	Number : Nombre de caracteres a ecrire
//	Attribute : Couleur d'arriere plan et des caracteres
// Sortie : Aucune
//*****************************************************************************
void PrintText(Point_t P, char * pString, int Number, Color_t Attribute);

//*****************************************************************************
// But de la procedure : Raffraichir l'affichage
// Entree : Aucune
// Sortie : Aucune
//*****************************************************************************
void Redraw(void);

//*****************************************************************************
// But de la fonction : Afficher le nom ainsi que la description d'une console
// Entree :
//	pConsole : Pointeur sur la console
//	X : Abscisses de depart de l'entete
//	Y : Ordonnes de depart de l'entete
//	FontColor : Couleur des caracteres
//	BackColor : Couleur du fond d'ecran
// Parametre retourne : FALSE si aucune entete, TRUE sinon
//*****************************************************************************
Status_t ConsoleHeader(CNode_t * pConsole, Color_t Attribute);

//*****************************************************************************
// But de la procedure : Dessiner une boite a l'ecran
// Entree :
//	Start : Coordonnees de depart de la boite
//	Size : Dimensions de la boite
//	BackColor : Couleur de l'arriere plan
// Sortie : Aucune
//*****************************************************************************
void FillBox(Point_t Start, Point_t Size, Color_t BackColor);

//*****************************************************************************
// But de la procedure : Deplacer vers le haut d'une ligne la visualisation de
// la console
// Entree :
//	pConsole : Pointeur sur la console
// Sortie : Aucune
//*****************************************************************************
void MoveUp(CNode_t * pConsole);

//*****************************************************************************
// But de la procedure : Deplacer vers le bas d'une ligne la visualisation de
// la console
// Entree :
//	pConsole : Pointeur sur la console
// Sortie : Aucune
//*****************************************************************************
void MoveDown(CNode_t * pConsole);

//*****************************************************************************
// But de la procedure : Deplacer vers la gauche la visualisation de la console
// Entree :
//	pConsole : Pointeur sur la console
// Sortie : Aucune
//*****************************************************************************
void MoveLeft(CNode_t * pConsole);

//*****************************************************************************
// But de la procedure : Deplacer vers la droite la visualisation de la console
// Entree :
//	pConsole : Pointeur sur la console
// Sortie : Aucune
//*****************************************************************************
void MoveRight(CNode_t * pConsole);

//*****************************************************************************
// But de la procedure : Deplacer vers le haut d'une page la visualisation de
// la console
// Entree :
//	pConsole : Pointeur sur la console
// Sortie : Aucune
//*****************************************************************************
void PageUp(CNode_t * pConsole);

//*****************************************************************************
// But de la procedure : Deplacer vers le bas d'une page la visualisation de
// la console
// Entree :
//	pConsole : Pointeur sur la console
// Sortie : Aucune
//*****************************************************************************
void PageDown(CNode_t * pConsole);

//*****************************************************************************
// But de la procedure : Deplacer d'une page vers la gauche la visualisation de
// la console
// Entree :
//	pConsole : Pointeur sur la console
// Sortie : Aucune
//*****************************************************************************
void PageLeft(CNode_t * pConsole);

//*****************************************************************************
// But de la procedure : Deplacer d'une page vers la droite la visualisation de
// la console
// Entree :
//	pConsole : Pointeur sur la console
// Sortie : Aucune
//*****************************************************************************
void PageRight(CNode_t * pConsole);

//*****************************************************************************
// But de la procedure : Aller en debut de page
// Entree : 
//	pConsole : Pointeur sur la console
// Sortie : Aucune
//*****************************************************************************
void PageHome(CNode_t * pConsole);

//*****************************************************************************
// But de la procedure : Aller en fin de page
// Entree : 
//	pConsole : Pointeur sur la console
// Sortie : Aucune
//*****************************************************************************
void PageEnd(CNode_t * pConsole);

//*****************************************************************************
// But de la procedure : Decaler le curseur a gauche
// Entree :
//	pConsole : Pointeur sur la console
// Sortie : Aucune
//*****************************************************************************
void CursorLeft(CNode_t * pConsole);

//*****************************************************************************
// But de la procedure : Decaler le curseur a droite
// Entree :
//	pConsole : Pointeur sur la console
// Sortie : Aucune
//*****************************************************************************
void CursorRight(CNode_t * pConsole);

//*****************************************************************************
// But de la procedure : Mettre ou non en mode insertion de caracteres
// Entree :
//	pConsole : Pointeur sur la console
// Sortie : Aucune
//*****************************************************************************
void InsertMode(CNode_t * pConsole);

//*****************************************************************************
// But de la fonction : Supprimer un caractere
// Entree :
//	pConsole : Pointeur sur la console
// Parametre retourne : TRUE si caractere supprime, FALSE sinon
//*****************************************************************************
Status_t Delete(CNode_t * pConsole);

//*****************************************************************************
// But de la procedure : Aller en debut de ligne
// Entree :
//	pConsole : Pointeur sur la console
// Sortie : Aucune
//*****************************************************************************
void Home(CNode_t * pConsole);

//*****************************************************************************
// But de la procedure : Aller en fin de ligne
// Entree :
//	pConsole : Pointeur sur la console
// Sortie : Aucune
//*****************************************************************************
void End(CNode_t * pConsole);

//*****************************************************************************
// But de la fonction : Placer le curseur a un endroit definit
// Entrees :
//	pConsole : Pointeur sur la console
//	pString : pointeur sur la chaine de caracteres contenant les coordonnees
//*****************************************************************************
Status_t SetCurPosition(CNode_t * pConsole, const char * pString);

//*****************************************************************************
// But de la fonction : Changer les couleurs de caracteres et de fond d'ecran
// Entrees :
//	pConsole : Pointeur sur la console
//	pString : pointeur sur la chaine de caracteres contenant les couleurs
//*****************************************************************************
Status_t SetConsoleColor(CNode_t * pConsole, const char * pString);

//*****************************************************************************
// But de la procedure : Copier le contenu de la console courante en RAM video
// Entree :
//	pConsole : Pointeur sur la console
// Sortie : Aucune
//*****************************************************************************
void VideoMemCopy(CNode_t * pConsole);

//*****************************************************************************

#endif
